{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "# Quantum algorithms for fast convolutions and hidden shifts\n",
        "\n",
        "Welcome, this notebook explores the execution of _hidden shift problems_ on a quantum computer.\n",
        "This notebook does assume some quantum knowledge.  We invite you to have a look into our 👋🌎 _Hello world_ samples in the notebook gallery and the [Quantum Katas](https://docs.microsoft.com/azure/quantum/tutorial-qdk-intro-to-katas) for introductory content on quantum computing.\n",
        "\n",
        "One way to think about the space of hidden shift problems\n",
        "is that we are using the quantum computer to help us compute the convolution of two functions. \n",
        "It turns out that a quantum computer can in principle compute convolutions in a super-fast way, which in turn is based on the quantum computer's ability to \n",
        "compute Fourier transforms in a super-fast way. The way convolutions are used is to find unknown shifts (\"offsets\") between two functions. We call this the \n",
        "\"hidden shift problem.\" Like Shor's algorithm for factoring, the hidden shift problem is a natural source of problems for which a quantum computer has an \n",
        "exponential advantage over the best known classical algorithms. \n",
        "This may eventually help in solving deconvolution problems and enable us to efficiently find patterns in complex data sets,\n",
        "for example finding the pattern on the right-hand side in the graph:\n",
        "\n",
        "<img src=\"\" />\n",
        "\n",
        "You can have a look into [arXiv:0812.0380](https://arxiv.org/abs/0812.0380) for general background on hidden shifts and related problems\n",
        "and into [arXiv:0811.3208](https://arxiv.org/abs/0811.3208) for the case of hidden shifts over Boolean functions.\n",
        "\n",
        "We will investigate the latter case, in which one is given two Boolean bent functions $f$ and $g$ with the promise that they satisfy the relation\n",
        "\n",
        "$$ g(x) = f(x \\oplus s) $$\n",
        "\n",
        "for all $x$, where $s$ is a hidden bitstring, called _shift_ that we would like to find.\n",
        "A Boolean function is _bent_ if it is as far from linear as possible. In\n",
        "particular, bent functions have flat Fourier spectra, such that each\n",
        "Fourier coefficient is equal in absolute value.\n",
        "\n",
        "In this case, the quantum algorithm described in [arXiv:0811.3208](https://arxiv.org/abs/0811.3208) uses\n",
        "black-box phase oracles $U_{f^\\star}$ and $U_g$ for $f^\\star$ and $g$, respectively, where $f^\\star$ is the dual bent function\n",
        "to $f$ (defined in more detail below), and computes the hidden shift $s$ between $f$ and $g$.\n",
        "\n",
        "The quantum circuit for this type of hidden shift problems is as follows:\n",
        "\n",
        "<img src=\"\" width=\"600px\" />\n",
        "\n",
        "Black-box phase oracles compute the value of a Boolean function $f(x)$ into the phase, i.e., $U_f = \\sum_x (-1)^{f(x)}|x\\rangle\\langle x|$.\n",
        "More information on phase oracles can be found in the [Quantum Katas](https://github.com/microsoft/QuantumKatas/tree/main/tutorials/Oracles).\n",
        "\n",
        "You can have a look into [arXiv:0812.0380](https://arxiv.org/abs/0812.0380) for general background on hidden shifts and related problems\n",
        "and into [arXiv:0811.3208](https://arxiv.org/abs/0811.3208) for the case of hidden shifts\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 1. Connect to the Azure Quantum workspace\n",
        "\n",
        "Let's start by connecting to the Azure Quantum service.\n",
        "We construct an instance of the `AzureQuantumProvider`. Note that it's imported from `azure.quantum.qiskit`."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [],
      "source": [
        "from azure.quantum.qiskit import AzureQuantumProvider\n",
        "provider = AzureQuantumProvider(\n",
        "    resource_id = \"\",\n",
        "    location = \"\"\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Next we are going to import some packages to describe and visualize quantum circuits from the `qiskit` package.\n",
        "We'll also import packages from _NumPy_ and _Matplotlib_ to create plots from the experimental data.\n",
        "Finally, we'll list the targets included in our workspace."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "This workspace's targets:\n",
            "- quantinuum.qpu.h1-1\n",
            "- quantinuum.sim.h1-1sc\n",
            "- quantinuum.sim.h1-1e\n",
            "- ionq.qpu\n",
            "- ionq.simulator\n"
          ]
        }
      ],
      "source": [
        "from qiskit import QuantumCircuit, QuantumRegister\n",
        "from qiskit.compiler import transpile\n",
        "from qiskit.tools.monitor import job_monitor\n",
        "from qiskit.visualization import plot_histogram\n",
        "\n",
        "import numpy as np\n",
        "from numpy.linalg import norm\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "print(\"This workspace's targets:\")\n",
        "for backend in provider.backends():\n",
        "    print(\"- \" + backend.name())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We will be using some of these targets in this notebook, but whenever you see such a target's name, note that you can easily exchange them by other targets in this list. (Note, however, that some of these targets are API validators and do not simulate or execute quantum functionality.)\n",
        "You can learn more about the various targets in the 👋🌎 _Hello world_ samples."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 2. Build a simple hidden shift problem\n",
        "\n",
        "Let's first create a function that creates hidden shift problems by passing to it phase oracle circuits for $U_g$ and $U_{f^\\star}$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [],
      "source": [
        "def hidden_shift(oracle_g, oracle_fstar):\n",
        "    \"\"\"Creates a hidden shift circuit based on phase oracle circuits for `oracle_g` and `oracle_fstar`.\"\"\"\n",
        "\n",
        "    # Obtain the number of qubits from oracle_g\n",
        "    num_qubits = oracle_g.num_qubits\n",
        "\n",
        "    # Check that number of qubits are the same for both oracles\n",
        "    assert num_qubits == oracle_fstar.num_qubits, \"Number of qubits for both oracles must be equal\"\n",
        "\n",
        "    # A quantum register for all qubits we are using in this circuit.\n",
        "    qs = QuantumRegister(num_qubits, name=\"q\")\n",
        "\n",
        "    # This constructs the quantum circuit\n",
        "    circ = QuantumCircuit(qs, name=\"Hidden shift\")\n",
        "\n",
        "    # A layer of H gates\n",
        "    circ.h(qs)\n",
        "\n",
        "    # Apply $U_g$ (rename it for visualization)\n",
        "    oracle_g.name = \"Ug\"\n",
        "    circ.append(oracle_g, qs)\n",
        "\n",
        "    # Another layer of H gates\n",
        "    circ.h(qs)\n",
        "\n",
        "    # Apply $U_{f^\\star}$\n",
        "    oracle_fstar.name = \"Uf*\"\n",
        "    circ.append(oracle_fstar, qs)\n",
        "\n",
        "    # And a final layer of H gates\n",
        "    circ.h(qs)\n",
        "    circ.measure_all()\n",
        "\n",
        "    return circ"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We have now a powerful routine to describe various hidden shift problems based on Boolean bent functions.\n",
        "The first bent function we will investigate is the inner product\n",
        "\n",
        "$$ f(x_1, \\dots, x_{2k}) = (x_1 \\land x_2) \\oplus (x_3 \\land x_4) \\oplus \\cdots \\oplus (x_{2k-1} \\land x_{2k}) $$\n",
        "\n",
        "An appealing property about this function is it's equal to its dual, i.e., $f^\\star = f$.\n",
        "The following helper circuit implements this function as a phase oracle $U_f$ by using CZ gates for each AND pair in the inner product.\n",
        "Its effect to the computational basis state $|x\\rangle$ is $(-1)^{f(x)}|x\\rangle$.\n",
        "In the following Python code the argument `num_qubits` corresponds to $2k$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [],
      "source": [
        "def inner_product(num_qubits):\n",
        "    \"\"\"Creates the inner product of two qubit registers, which are the alternating qubits over `num_qubits` bits\"\"\"\n",
        "\n",
        "    # Number of qubits must be even\n",
        "    assert num_qubits % 2 == 0, \"Number of qubits must be even\"\n",
        "\n",
        "    # Create a quantum circuit\n",
        "    circ = QuantumCircuit(num_qubits, name='inner_product')\n",
        "    # Apply CZ gates to pairs of even and odd qubit indices\n",
        "    for c, t in zip(circ.qubits[::2], circ.qubits[1::2]):\n",
        "        circ.cz(c, t)\n",
        "    return circ"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Next, we want to implement $g(x) = f(x \\oplus s)$ for some shift $s$.\n",
        "For this purpose, we first construct a building block that computes the XOR operation with $s$ (passed as argument `shift`) in-place into a quantum register of length `num_bits`.\n",
        "More precisely, the action of this building block on the computational basis state $|x\\rangle$ is $|x \\oplus s\\rangle$, where $\\oplus$ is the bit-wise XOR operation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [],
      "source": [
        "def xor(shift, num_bits):\n",
        "    \"\"\"Bitwise XOR of `num_bits`-bit value `shift`\"\"\"\n",
        "\n",
        "    # Shift must be smaller than 2^num_bits\n",
        "    assert shift >= 0 and shift < 2**num_bits, f\"Shift must be between 0 and {2**num_bits - 1}\"\n",
        "\n",
        "    # Create a quantum circuit with `num_bits` qubits\n",
        "    circ = QuantumCircuit(num_bits, name=f'xor({shift})')\n",
        "    # Returns all indexes which correspond to a `1` in the binary expansion of `shift`\n",
        "    ones = [idx for idx in range(num_bits) if (shift >> idx) & 1 == 1]\n",
        "    # Apply an X operation to all indexes in `ones` (this only works if `ones` is not empty)\n",
        "    if ones:\n",
        "        circ.x(ones)\n",
        "\n",
        "    return circ"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The next helper function takes as input a phase oracle $U_f$ and creates a phase oracle $U_g$ such that $g(x) = f(x \\oplus s)$ by conjugating the phase oracle with the XOR operation we just defined."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [],
      "source": [
        "def shifted_phase_oracle(shift, phase_oracle):\n",
        "    \"\"\"Creates U_g from U_f (phase_oracle), where g(x) = f(x ⊕ s)\"\"\"\n",
        "    # Retrieve qubits from input phase oracle\n",
        "    qs = phase_oracle.qubits\n",
        "    # Create a quantum circuit using the qubits from the phase oracle\n",
        "    circ = QuantumCircuit(qs)\n",
        "    # Compute shift into the computational state using the XOR operation\n",
        "    circ.append(xor(shift, phase_oracle.num_qubits), qs)\n",
        "    # Apply the phase oracle onto the shifted state\n",
        "    circ.append(phase_oracle, qs)\n",
        "    # Uncompute the shift by applying the XOR operation another time\n",
        "    circ.append(xor(shift, phase_oracle.num_qubits), qs)\n",
        "\n",
        "    return circ"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "We are now equipped to build a first simple hidden shift problem using the inner product as bent function.\n",
        "We configure the problem by its size `num_qubits`, which should be an even number, and represents the overall number of qubits $n$ in the circuit,\n",
        "and `shift` which is a non-negative number smaller than $2^n$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐┌─────┐┌───┐┌──────┐┌───┐ ░ ┌─┐         \n",
              "   q_0: ┤ H ├┤0    ├┤ H ├┤0     ├┤ H ├─░─┤M├─────────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░ └╥┘┌─┐      \n",
              "   q_1: ┤ H ├┤1    ├┤ H ├┤1     ├┤ H ├─░──╫─┤M├──────\n",
              "        ├───┤│  Ug │├───┤│  Uf* │├───┤ ░  ║ └╥┘┌─┐   \n",
              "   q_2: ┤ H ├┤2    ├┤ H ├┤2     ├┤ H ├─░──╫──╫─┤M├───\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║  ║ └╥┘┌─┐\n",
              "   q_3: ┤ H ├┤3    ├┤ H ├┤3     ├┤ H ├─░──╫──╫──╫─┤M├\n",
              "        └───┘└─────┘└───┘└──────┘└───┘ ░  ║  ║  ║ └╥┘\n",
              "meas: 4/══════════════════════════════════╩══╩══╩══╩═\n",
              "                                          0  1  2  3 </pre>"
            ],
            "text/plain": [
              "        ┌───┐┌─────┐┌───┐┌──────┐┌───┐ ░ ┌─┐         \n",
              "   q_0: ┤ H ├┤0    ├┤ H ├┤0     ├┤ H ├─░─┤M├─────────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░ └╥┘┌─┐      \n",
              "   q_1: ┤ H ├┤1    ├┤ H ├┤1     ├┤ H ├─░──╫─┤M├──────\n",
              "        ├───┤│  Ug │├───┤│  Uf* │├───┤ ░  ║ └╥┘┌─┐   \n",
              "   q_2: ┤ H ├┤2    ├┤ H ├┤2     ├┤ H ├─░──╫──╫─┤M├───\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║  ║ └╥┘┌─┐\n",
              "   q_3: ┤ H ├┤3    ├┤ H ├┤3     ├┤ H ├─░──╫──╫──╫─┤M├\n",
              "        └───┘└─────┘└───┘└──────┘└───┘ ░  ║  ║  ║ └╥┘\n",
              "meas: 4/══════════════════════════════════╩══╩══╩══╩═\n",
              "                                          0  1  2  3 "
            ]
          },
          "execution_count": 7,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "num_qubits = 4\n",
        "shift = 5\n",
        "\n",
        "# Create phase oracle circuit for $f^\\star$\n",
        "oracle_fstar = inner_product(num_qubits)\n",
        "\n",
        "# Create phase oracle circuit for $g$\n",
        "oracle_g = shifted_phase_oracle(shift, oracle_fstar)\n",
        "\n",
        "# Create hidden shift circuit\n",
        "circ = hidden_shift(oracle_g, oracle_fstar)\n",
        "\n",
        "# Print out the circuit (and ensure that the circuit is not paginated)\n",
        "circ.draw(fold=-1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 3. Submit the quantum program to IonQ's and Quantinuum's simulators\n",
        "\n",
        "Next, we are executing this circuit on IonQ's full-state simulator `ionq.simulator` and on Quantinuum's simulator `quantinuum.sim.h1-1e`.\n",
        "Afterwards, we will write a loop in which we run several experiments using various shifts.\n",
        "Before sending the circuit to a backend, we must expand all building blocks.\n",
        "The easiest way to do this is by transpiling the quantum circuit into the target gate set of the backend's quantum computer.\n",
        "To this end, we construct a backend, and call the `transpile` function to obtain\n",
        "an expanded and possibly optimized quantum circuit (note that the `X` gates were merged with the `H` gates).\n",
        "Note that any target you have enabled in this workspace can\n",
        "be used here. Azure Quantum makes it extremely easy to submit\n",
        "the same quantum program to different providers."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌─────────┐   ┌──────────┐   ┌───┐ ░ ┌─┐         \n",
              "   q_0: ┤ Ry(π/2) ├─■─┤ Ry(-π/2) ├─■─┤ H ├─░─┤M├─────────\n",
              "        └──┬───┬──┘ │ └──┬───┬───┘ │ ├───┤ ░ └╥┘┌─┐      \n",
              "   q_1: ───┤ H ├────■────┤ H ├─────■─┤ H ├─░──╫─┤M├──────\n",
              "        ┌──┴───┴──┐   ┌──┴───┴───┐   ├───┤ ░  ║ └╥┘┌─┐   \n",
              "   q_2: ┤ Ry(π/2) ├─■─┤ Ry(-π/2) ├─■─┤ H ├─░──╫──╫─┤M├───\n",
              "        └──┬───┬──┘ │ └──┬───┬───┘ │ ├───┤ ░  ║  ║ └╥┘┌─┐\n",
              "   q_3: ───┤ H ├────■────┤ H ├─────■─┤ H ├─░──╫──╫──╫─┤M├\n",
              "           └───┘         └───┘       └───┘ ░  ║  ║  ║ └╥┘\n",
              "meas: 4/══════════════════════════════════════╩══╩══╩══╩═\n",
              "                                              0  1  2  3 </pre>"
            ],
            "text/plain": [
              "        ┌─────────┐   ┌──────────┐   ┌───┐ ░ ┌─┐         \n",
              "   q_0: ┤ Ry(π/2) ├─■─┤ Ry(-π/2) ├─■─┤ H ├─░─┤M├─────────\n",
              "        └──┬───┬──┘ │ └──┬───┬───┘ │ ├───┤ ░ └╥┘┌─┐      \n",
              "   q_1: ───┤ H ├────■────┤ H ├─────■─┤ H ├─░──╫─┤M├──────\n",
              "        ┌──┴───┴──┐   ┌──┴───┴───┐   ├───┤ ░  ║ └╥┘┌─┐   \n",
              "   q_2: ┤ Ry(π/2) ├─■─┤ Ry(-π/2) ├─■─┤ H ├─░──╫──╫─┤M├───\n",
              "        └──┬───┬──┘ │ └──┬───┬───┘ │ ├───┤ ░  ║  ║ └╥┘┌─┐\n",
              "   q_3: ───┤ H ├────■────┤ H ├─────■─┤ H ├─░──╫──╫──╫─┤M├\n",
              "           └───┘         └───┘       └───┘ ░  ║  ║  ║ └╥┘\n",
              "meas: 4/══════════════════════════════════════╩══╩══╩══╩═\n",
              "                                              0  1  2  3 "
            ]
          },
          "execution_count": 8,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "ionq_backend = provider.get_backend(\"ionq.simulator\")\n",
        "\n",
        "transpiled = transpile(circ, ionq_backend)\n",
        "transpiled.draw()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now we are submitting the transpiled circuit to the selected backend for 100 shots.\n",
        "We'll get back a `job` instance and print its job ID."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Job id: a9aceb1c-9ec4-11ec-93c4-acde48001122\n"
          ]
        }
      ],
      "source": [
        "# Using the IonQ simulator target, call \"run\" to submit the job. We'll\n",
        "# use 100 shots (simulated runs).\n",
        "job = ionq_backend.run(transpiled, shots=100)\n",
        "print(\"Job id:\", job.id())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The job ID can be used to retrieve the results later using the [`get_job` method](https://learn.microsoft.com/azure/quantum/optimization-workspace#workspaceget_job) or by viewing it under the **Job management** section of the portal.\n",
        "\n",
        "You can monitor the job status with Qiskit's `job_monitor` function.\n",
        "\n",
        "This may take a minute or so ⏳. Your job will be packaged and sent to IonQ, where it will wait its turn to be run. You'll see your job go through these stages: \"job is queued\" -> \"job is actively running\" -> \"job has successfully run.\"\n",
        "Once the job has finished, we are retrieving the counts from the backend.\n",
        "With IonQ's full state simulator, we should see a 100% probability only for the selected shift."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Job Status: job has successfully run\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 504x360 with 1 Axes>"
            ]
          },
          "execution_count": 10,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "job_monitor(job)\n",
        "result = job.result()\n",
        "plot_histogram(result.get_counts(transpiled), title=\"Result\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Now we'll create a backend for Quantinuum's noisy simulator.  Before we running the circuit, we are going to estimate the cost of simulating the circuit (To learn more about job pricing, review [the Azure Quantum docs](https://docs.microsoft.com/azure/quantum/azure-quantum-job-costs).)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Estimated cost: 6.64 HQC\n"
          ]
        }
      ],
      "source": [
        "# This time we are creating a backend for Quantinuum's emulator, which also simulates noise.\n",
        "quantinuum_backend = provider.get_backend(\"quantinuum.sim.h1-1e\")\n",
        "\n",
        "# We transpile the circuit into the backend's instruction set.\n",
        "transpiled = transpile(circ, quantinuum_backend)\n",
        "\n",
        "# And we estimate the cost of simulating the circuit 100 times.\n",
        "cost = quantinuum_backend.estimate_cost(transpiled, count=100)\n",
        "print(f\"Estimated cost: {cost.estimated_total} {cost.currency_code}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "The next code section is commented out to prevent accidental costs.  Uncomment the code to run the code on the Quantinuum noisy simulator."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [],
      "source": [
        "# job = quantinuum_backend.run(transpiled, count=100)\n",
        "# print(\"Job id:\", job.id())\n",
        "# job_monitor(job)\n",
        "# result = job.result()\n",
        "# plot_histogram(result.get_counts(transpiled), title=\"Result\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 4. Create a large experiment and a 3D histogram plot\n",
        "\n",
        "Based on what we have learned, we are now running a more involved.\n",
        "We want to explore the quantum circuit measurement results for multiple shifts, possibly all shifts.\n",
        "We are then plotting the histogram for each experiment in a 3D bar plot,\n",
        "where one axis shows all possible measurement outcomes, and the other axis lists all experiments for various shifts.\n",
        "We expect to see some skyscrapers reaching out whenever the shift corresponds to the measurement outcome."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n",
            "Job Status: job has successfully run\n"
          ]
        }
      ],
      "source": [
        "# Number of qubits in the hidden shift experiment\n",
        "num_qubits = 4\n",
        "# List of shifts to perform (set to `range(1 << num_qubits)` to run all shifts)\n",
        "shifts = range(1 << num_qubits)\n",
        "# Store histogram data for all shifts in a matrix\n",
        "histogram = np.zeros((len(shifts), 1 << num_qubits))\n",
        "\n",
        "# Creates an experiment circuit based on shift\n",
        "def experiment_circuit(shift):\n",
        "    oracle_f = inner_product(num_qubits)\n",
        "    oracle_g = shifted_phase_oracle(shift, oracle_f)\n",
        "    circ = hidden_shift(oracle_g, oracle_fstar)\n",
        "    transpiled = transpile(circ, ionq_backend)\n",
        "    return transpiled\n",
        "\n",
        "# Submit jobs for each shift\n",
        "jobs = [ionq_backend.run(experiment_circuit(shift), shots=100) for shift in shifts]\n",
        "\n",
        "# After we submitted all the jobs, we wait for each of them.\n",
        "# It does not matter whether jobs finishes in a different order than they were executed, since we\n",
        "# traverse the jobs in the same order as they were executed.\n",
        "for row, job in enumerate(jobs):\n",
        "    # Wait for the job to finish\n",
        "    job_monitor(job)\n",
        "\n",
        "    # Retrieve all counts from the job\n",
        "    counts = job.result().get_counts()\n",
        "\n",
        "    # Retrieve the counts for all input assignments\n",
        "    histogram[row] = [counts.get(format(idx, f\"0{num_qubits}b\")) or 0 for idx in range(1 << num_qubits)]\n",
        "\n",
        "    # Compute probabilities from counts\n",
        "    histogram[row] /= norm(histogram[row], ord=1)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1440x720 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "# Set up the figure and axes to print the 3D-bar plot\n",
        "fig = plt.figure(figsize=(20, 10))\n",
        "ax = fig.add_subplot(1, 1, 1, projection='3d')\n",
        "\n",
        "# Create x and y coordinates for the grid based on the dimensions of the matrix\n",
        "x_grid, y_grid = np.meshgrid(np.arange(1 << num_qubits), np.arange(len(shifts)))\n",
        "\n",
        "# Flatten matrices into lists\n",
        "x, y = x_grid.ravel(), y_grid.ravel()\n",
        "top = histogram.ravel()\n",
        "\n",
        "bottom = np.zeros_like(top)\n",
        "\n",
        "ax.bar3d(x, y, bottom, 1, 1, top, shade=True)\n",
        "ax.set_title(f'3D-bar plot for hidden shift on {num_qubits} qubits')\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 5. Investigating more complex bent functions\n",
        "\n",
        "The inner product bent function can be generalized to the family of Maiorana-McFarland bent functions\n",
        "$$ f(x, y) = x\\pi(y)^t \\oplus h(y) $$\n",
        "where $x = x_1, \\dots, x_k$, $y = y_1, \\dots, y_n$, and $\\pi \\in S_{2^k}$ is a permutation of all possible $2^k$ bitstrings of length $k$.\n",
        "The inner product $x\\pi(y)^t$ is as defined above, and $h$ can be any $k$-input function.\n",
        "The dual function of a Maiorana-McFarland function is\n",
        "$$ f^\\star(x, y) = \\pi^{-1}(x)y^t \\oplus h(\\pi^{-1}(x)) $$\n",
        "where $\\pi^{-1}$ is the inverse permutation to $\\pi$.\n",
        "\n",
        "The next function can create phase oracles for some of these Maiorana-McFarland functions $f$ and their dual $f^\\star$, in which $h = 0$ and $\\pi \\in S_{2^k}$ is defined via an index permutation $\\sigma \\in S_k$ such that\n",
        "$ \\pi((b_{k-1}\\dots b_0)_2) \\mapsto (b_{\\sigma(k-1)} \\dots b_{\\sigma(0)})_2 $.\n",
        "Such permutations can easily be implemented using SWAP gates on the input qubits and we are using the `Permutation` class to find these SWAP gates automatically."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [],
      "source": [
        "from qiskit.circuit.library.generalized_gates.permutation import Permutation\n",
        "\n",
        "def maiorana_mcfarland_bent_function(num_qubits, index_permutation):\n",
        "    \"\"\"Creates Maiorana-McFarland bent function based on index permutation\"\"\"\n",
        "\n",
        "    assert num_qubits % 2 == 0, \"Number of qubits must be even\"\n",
        "\n",
        "    # Create permutation circuit based on index_permutation.\n",
        "    # Note that the permutation is only applied on half the qubits\n",
        "    perm = Permutation(num_qubits // 2, index_permutation)\n",
        "\n",
        "    # We are considering the even qubits in this circuits corresponding to x in the definition\n",
        "    # above, and the odd qubits corresponding to y in the definition above.\n",
        "\n",
        "    # Create phase oracle for f\n",
        "    circ_f = QuantumCircuit(num_qubits, name=\"maiorana_mcfarland\")\n",
        "    # Apply permutation to qubits corresponding to x\n",
        "    circ_f.append(perm, range(0, num_qubits, 2))\n",
        "    # Apply inner product to x and y\n",
        "    circ_f.append(inner_product(num_qubits), range(num_qubits))\n",
        "    # Invert permutation on x\n",
        "    circ_f.append(perm.reverse_ops(), range(0, num_qubits, 2))\n",
        "\n",
        "    # Create phase oracle for f_star\n",
        "    circ_fstar = QuantumCircuit(num_qubits, name=\"maiorana_mcfarland\")\n",
        "    # Apply inverse permutation to qubits corresponding to y\n",
        "    circ_fstar.append(perm.reverse_ops(), range(1, num_qubits, 2))\n",
        "    # Apply inner product to x and y\n",
        "    circ_fstar.append(inner_product(num_qubits), range(num_qubits))\n",
        "    # Invert permutation on y\n",
        "    circ_fstar.append(perm, range(1, num_qubits, 2))\n",
        "\n",
        "    # Return both circuits\n",
        "    return circ_f, circ_fstar"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Let's try an instance of this new family of bent functions.  We are creating a hidden shift problem with 6 qubits and apply the index permutation $(1, 2, 0)$.  Do you know which answer is hidden in the shift (👍), and also let's see if the quantum computer can discover it?"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "dotnet_interactive": {
          "language": "csharp"
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Job Status: job has successfully run\n",
            "{'101010': 100}\n"
          ]
        }
      ],
      "source": [
        "num_qubits = 6\n",
        "qubit_permutation = [1, 2, 0]\n",
        "shift = 0b101010               # The answer ;)\n",
        "\n",
        "# Create phase oracles for $f$ and $f^star$\n",
        "oracle_f, oracle_fstar = maiorana_mcfarland_bent_function(num_qubits, qubit_permutation)\n",
        "# Create phase oracle for $g = f(x ⊕ s)$\n",
        "oracle_g = shifted_phase_oracle(shift, oracle_f)\n",
        "\n",
        "# Create hidden shift problem based on oracles\n",
        "circ = hidden_shift(oracle_g, oracle_fstar)\n",
        "# Transpile hidden shift circuit for the backend\n",
        "transpiled = transpile(circ, ionq_backend)\n",
        "\n",
        "# Submit a job\n",
        "job = ionq_backend.run(transpiled, shots=100)\n",
        "\n",
        "# Await the job\n",
        "job_monitor(job)\n",
        "\n",
        "# Print the job's result\n",
        "print(job.result().get_counts())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "## 6. Investigating the impact of noise on the quantum algorithm\n",
        "\n",
        "In this section we do a simple experiment that adds noise to the quantum simulation and see what happens when we crank up\n",
        "the number of quantum gates in the circuit, in particular, if we increase the number of entangling gates such as CZ or CNOT \n",
        "significantly. We expect to see a less clear peak at the correct shift and want to see this in the histogram data coming \n",
        "back from emulating the circuit. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [],
      "source": [
        "def toffoli_oracles(num_qubits):\n",
        "    \"\"\"Create two oracles for the hidden shift problem that use Toffoli gates for a state space permutation.\"\"\"\n",
        "    assert num_qubits >= 6, \"Number of bits must be at least 6\"\n",
        "\n",
        "    circ_f = QuantumCircuit(num_qubits, name='IP with Toffoli')\n",
        "    circ_f.ccx(4, 2, 0)\n",
        "    circ_f.ccx(0, 2, 4)\n",
        "    circ_f.append(inner_product(num_qubits), range(num_qubits))\n",
        "    circ_f.ccx(0, 2, 4)\n",
        "    circ_f.ccx(4, 2, 0)\n",
        "\n",
        "    circ_fstar = QuantumCircuit(num_qubits, name='IP with Toffoli')\n",
        "    circ_fstar.ccx(1, 3, 5)\n",
        "    circ_fstar.ccx(5, 3, 1)\n",
        "    circ_fstar.append(inner_product(num_qubits), range(num_qubits))\n",
        "    circ_fstar.ccx(5, 3, 1)\n",
        "    circ_fstar.ccx(1, 3, 5)\n",
        "\n",
        "    return circ_f, circ_fstar"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "Let us next create a concrete instance of the problem with 6 qubits and a shift of 17.  Then, let's draw the circuit."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [
        {
          "data": {
            "text/html": [
              "<pre style=\"word-wrap: normal;white-space: pre;background: #fff0;line-height: 1.1;font-family: &quot;Courier New&quot;,Courier,monospace\">        ┌───┐┌─────┐┌───┐┌──────┐┌───┐ ░ ┌─┐               \n",
              "   q_0: ┤ H ├┤0    ├┤ H ├┤0     ├┤ H ├─░─┤M├───────────────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░ └╥┘┌─┐            \n",
              "   q_1: ┤ H ├┤1    ├┤ H ├┤1     ├┤ H ├─░──╫─┤M├────────────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║ └╥┘┌─┐         \n",
              "   q_2: ┤ H ├┤2    ├┤ H ├┤2     ├┤ H ├─░──╫──╫─┤M├─────────\n",
              "        ├───┤│  Ug │├───┤│  Uf* │├───┤ ░  ║  ║ └╥┘┌─┐      \n",
              "   q_3: ┤ H ├┤3    ├┤ H ├┤3     ├┤ H ├─░──╫──╫──╫─┤M├──────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║  ║  ║ └╥┘┌─┐   \n",
              "   q_4: ┤ H ├┤4    ├┤ H ├┤4     ├┤ H ├─░──╫──╫──╫──╫─┤M├───\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║  ║  ║  ║ └╥┘┌─┐\n",
              "   q_5: ┤ H ├┤5    ├┤ H ├┤5     ├┤ H ├─░──╫──╫──╫──╫──╫─┤M├\n",
              "        └───┘└─────┘└───┘└──────┘└───┘ ░  ║  ║  ║  ║  ║ └╥┘\n",
              "meas: 6/══════════════════════════════════╩══╩══╩══╩══╩══╩═\n",
              "                                          0  1  2  3  4  5 </pre>"
            ],
            "text/plain": [
              "        ┌───┐┌─────┐┌───┐┌──────┐┌───┐ ░ ┌─┐               \n",
              "   q_0: ┤ H ├┤0    ├┤ H ├┤0     ├┤ H ├─░─┤M├───────────────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░ └╥┘┌─┐            \n",
              "   q_1: ┤ H ├┤1    ├┤ H ├┤1     ├┤ H ├─░──╫─┤M├────────────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║ └╥┘┌─┐         \n",
              "   q_2: ┤ H ├┤2    ├┤ H ├┤2     ├┤ H ├─░──╫──╫─┤M├─────────\n",
              "        ├───┤│  Ug │├───┤│  Uf* │├───┤ ░  ║  ║ └╥┘┌─┐      \n",
              "   q_3: ┤ H ├┤3    ├┤ H ├┤3     ├┤ H ├─░──╫──╫──╫─┤M├──────\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║  ║  ║ └╥┘┌─┐   \n",
              "   q_4: ┤ H ├┤4    ├┤ H ├┤4     ├┤ H ├─░──╫──╫──╫──╫─┤M├───\n",
              "        ├───┤│     │├───┤│      │├───┤ ░  ║  ║  ║  ║ └╥┘┌─┐\n",
              "   q_5: ┤ H ├┤5    ├┤ H ├┤5     ├┤ H ├─░──╫──╫──╫──╫──╫─┤M├\n",
              "        └───┘└─────┘└───┘└──────┘└───┘ ░  ║  ║  ║  ║  ║ └╥┘\n",
              "meas: 6/══════════════════════════════════╩══╩══╩══╩══╩══╩═\n",
              "                                          0  1  2  3  4  5 "
            ]
          },
          "execution_count": 18,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "num_qubits = 6\n",
        "shift = 17\n",
        "\n",
        "# Create phase oracles for $f$ and $f^star$\n",
        "oracle_f, oracle_fstar = toffoli_oracles(num_qubits)\n",
        "# Create phase oracle for $g = f(x ⊕ s)$\n",
        "oracle_g = shifted_phase_oracle(shift, oracle_f)\n",
        "\n",
        "# Create hidden shift problem based on oracles\n",
        "circ = hidden_shift(oracle_g, oracle_fstar)\n",
        "\n",
        "# Print out the circuit (and ensure that the circuit is not paginated)\n",
        "circ.draw(fold=-1)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "Next, we are sending this circuit to Quantinuum's emulator `quantinuum.sim.h1-1e`. We can use the `quantinuum_backend` instance that we created earlier, and call the `transpile` function to obtain an expanded and possibly optimized quantum circuit (note that the `X` gates were merged with the `H` gates).  Before submitting the circuit to the backend, we print the estimated cost for execution."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Estimated cost: 8.96 HQC\n"
          ]
        }
      ],
      "source": [
        "transpiled = transpile(circ, quantinuum_backend)\n",
        "\n",
        "# And we estimate the cost of simulating the circuit 100 times\n",
        "cost = quantinuum_backend.estimate_cost(transpiled, count=100)\n",
        "print(f\"Estimated cost: {cost.estimated_total} {cost.currency_code}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "Now, we submit the transpiled circuit to the selected backend for 100 shots.\n",
        "\n",
        "The next code section is commented out to prevent accidental costs.  Uncomment the code to run the code on the Quantinuum noisy simulator."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "jupyter": {
          "outputs_hidden": false,
          "source_hidden": false
        },
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "outputs": [],
      "source": [
        "# # Using the simulator target, call \"run\" to submit the job.\n",
        "# job = quantinuum_backend.run(transpiled, count=100)\n",
        "\n",
        "# # Get the job results (this method also waits for the Job to complete):\n",
        "# result = job.result()\n",
        "# # The histogram returned by the results can be sparse, so here we add any of the missing bitstring labels.\n",
        "# counts = {format(n, \"03b\"): 0 for n in range(8)}\n",
        "# counts.update(result.get_counts(circ))\n",
        "# plot_histogram(counts)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "nteract": {
          "transient": {
            "deleting": false
          }
        }
      },
      "source": [
        "As expected, we see a peak at the correct solution for the shift, which is $17$ or as a binary pattern $10001$. There are other \n",
        "bitstrings that are being picked up which is due to the noise of the emulated quantum device. Note that by changing the provider \n",
        "using the function `provider.get_backend` above, it is possible to run the same code also against QPUs. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## 7. Next steps\n",
        "\n",
        "We hope you enjoyed our tour through various hidden shift problems.  We encourage you to explore this notebook further, for example by:\n",
        "\n",
        "* Configuring different hidden shift problems based on the provided helper circuits\n",
        "* Trying out different backends: How would the 3D-bar plot look like when running on a real QPU? Just replace `ionq.simulator` by `ionq.qpu`.\n",
        "* Implementing new phase oracles for bent functions: What about Maiorana-McFarland bent functions in which $h \\neq 0$ or $\\pi$ is not an index permutation?\n",
        "* Try this [Hidden Shift sample using Q# standalone](https://github.com/microsoft/Quantum/tree/main/samples/azure-quantum/hidden-shift#finding-hidden-shift-of-bent-functions-using-the-azure-quantum-service), or create a [python host program](https://docs.microsoft.com/azure/quantum/user-guide/host-programs?tabs=tabid-python#q-with-host-programs) to run the Q# sample using python.\n",
        "\n",
        "To learn more about submitting Qiskit circuits to Azure Quantum, review [the Azure Quantum documentation](https://docs.microsoft.com/azure/quantum/quickstart-microsoft-qiskit?pivots=platform-ionq).\n",
        "\n",
        "To learn more about job pricing, also review [the Azure Quantum documentation](https://docs.microsoft.com/azure/quantum/azure-quantum-job-costs)."
      ]
    }
  ],
  "metadata": {
    "kernel_info": {
      "name": "python3"
    },
    "kernelspec": {
      "display_name": "Python 3.9.2 64-bit",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.9.2"
    },
    "nteract": {
      "version": "nteract-front-end@1.0.0"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "81794d4967e6c3204c66dcd87b604927b115b27c00565d3d43f05ba2f3a2cb0d"
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}
